﻿#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main() {//C语言规定main函数是程序的入口 仅能有一个
	printf("Helloword\n");
	printf("Helloword\n");
	printf("Helloword\n");

	return 0;
}//printf 是一个库函数,用来打印数据 #include <stdio.h>
//char 字符型
//short 短整型
//int 整形
//long 长整型
//long long 更长的整型
//float 单精度浮点型
//double 双精度浮点型
 
int main()
{
	printf("%zu\n", sizeof(char)); //%zu 打印一个sizeof返回的无符号整型       
	//1 2 4 4 8 4 8  单位是字节
	printf("%zu\n", sizeof(short));
	printf("%zu\n", sizeof(int));
	printf("%zu\n", sizeof(long));
	printf("%zu\n", sizeof(long long));
	printf("%zu\n", sizeof(float));
	printf("%zu\n", sizeof(double));
	return 0;
}

int main()
{
	int age = 10;
	double price = 66.6;

	return 0;
}

//局部变量 全局变量 s
//局部优先  局部变量名不能重复定义 全局和局部可以一样 但不建议
int main() {
	float weight = 88.5;
	printf("weight=%d\n", weight);
	return 0;
}



//#define _CRT_SECURE_NO_WARNINGS
int main() 
{
	int num1 = 0;
	int num2 = 0;
	scanf("%d %d", &num1, &num2);
	int sum = num1 + num2;
	printf("%d\n", sum);

	return 0;

}
//scanf_s 这个函数是vs编译器自己提供的函数非标准c提供的函数 只有vs认识 别的编译器不认识
//
//
//变量的作用域和生命周期
//
//声明外部符号extern
extern int a;
//全局变量的作用域是整个工程

int a = 10

void test()
{
	printf("test-->%d\n", a);
}
int main()
{
	test();
	{
		//int a = 10;
		printf("%d\n", a);
	}
	printf("%d\n", a);
	return 0;
}
// 字面常量
//const 修饰的常变量
//define 定义的标识符常量
//枚举常量
//
//字面常量
int main()
{
	30;
	3.14;
	'z';//字符
	"abc";//
	return 0;
}

//const修饰的常变量
int main()
{
	const int a = 10;
	a = 30;//const修饰a 本质是变量 但不能被修改 有着常量的属性
	printf("%d\n", a);
	int n = 10;
	int arr[n] = {};

	return 0;
}

//#define 定义的标识符常量

#define MAX 100
#define STR "abcdefghi"
int main()
{
	printf("%d\n", MAX);
	int a = MAX;
	printf("%d\n",a);
	MAX = 200;//不能改
	printf("%s\n", STR);
	return 0;
}

//枚举常量
enum color
{
	//枚举常量
	RED,
	GREEN,
	BLUE
};
int main()
{
	//三原色 
	//Red Green Blue
	int num = 10;
	enum color c = RED;
	printf("%s\n",c);
 //RED=10;
 //不可以做
	return 0;
}
enum SEX {
	MALE,
	FEMALE,
	SECRET
};

int main()
{
	// char 字符类型
	//'a' 
	char ch = 'a';  //ch字符变量		
	//字符串
	//"abcdef";//双引号引起的一串字符叫字符串字面值  c语言中没有字符串类型
	//字符串要存起来的话可以放在字符数组里
	char arr1[] = "abcdef";//字符串结束标志是\0
	char arr2[] = {'a','b','c','d','e','f'};
	printf("%s\n", arr1);
	printf("%s\n", arr2);
	int len = strlen(arr2);//string length  求字符串长度  是库函数 头文件 string.h
	printf("%d\n", len);
	printf("%d\n", strlen(arr1));
	return 0;
}

int main()
{
	printf("abcn");
	printf("abc\n");
	return 0;
}

int main()   
{
	printf("abc\0efg");
	return 0;
}


int main()
{

	printf("%s\n", "(are you ok \?\? )");
	printf("%c\n", '\'');
	printf("%s\n", "abcdef"); //只能字符串可以简写printf("abcdef");
	printf("abcd\\0ef");
	printf("c:\\test\\test.c");//路径一定要转义 
	printf("\a"); //引发电脑蜂鸣
	printf("aaa\bfe\fcjs\vjefi\rid");
	
	//\n 换行 \?\?( -> [ \?\?) -> ]防止三元字母词 \r回车 \a蜂鸣 \b退格 \f进纸 \' \" \\转(义为原字符 \t水平制表符(打印地址一定加) \v垂直制表符 
	
	printf("%c\n",'\120');//\ddd八进制
	printf("%c\n", '\x22');//\xdd十六进制

	printf("%d\n", strlen("abcde f"));
	printf("%d\n", strlen("c:\test\628\test.c"));//到127

	return 0;
}

//注释 
// 梳理思路
// 解释复杂代码
// 帮助自己帮助别人

//选择语句
int main()
{
	int input = 0;
	printf("要好好学习吗?(1/0)");
	scanf("%d", &input);
	if (input == 1) {
		printf("好offer\n");
	}
	else {
		printf("卖地瓜\n");
	}
	return 0;
}

//C语言实现选择
//if else
//switch

//循环语句
int main()
{
	//两万行有效代码!
	int line = 0;
	printf("加入比特\n");
	while (line < 20000) {
		printf("写代码:%d\n",line);
		line++;
	}
	if (line >= 20000) {
		printf("人生巅峰\n");
	}
	else {
		printf("继续加油\n");
	}
	return 0;
}

//顺序 选择 循环

//函数
//求两个任意整数的和

int main()
{
	int n1 = 0;
	int n2 = 0;
	printf("请输入两个整数\n");
	scanf("%d %d", &n1, &n2);
	int sum = n1 + n2;
	printf("%d\n", sum);
	return 0;
}

ADD(int x,int y)
{
	int z = 0;
	z = x + y;
	return z;
}
int main()
{
	int n1 = 0;
	int n2 = 0;
	printf("请输入两个整数\n");
	scanf("%d %d", &n1, &n2);
	int sum = ADD(n1, n2);
	/*int t1 = 100;
	int t2 = 123;
	int bb=ADD(t1, t2);
	printf("%d\n", bb);*/
	printf("%d\n", sum);
	return 0;
}

//add  函数名
//int x ,int y 函数参数
//{
// int z=0
// z=
// return z
// }  函数体 

//数组
int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	//printf("%d\n", arr[8]);
	int i = 0;
	while (i < 10) {
		printf("%d ", arr[i]);
		i++;
	}
	return 0;
}

//数据类型
//内置的 char short int long longlong float double
//自定义 struct....

//局部变量的作用域 局部变量所在的局部范围

int num = 0;
int main()
{
	int num = 1;
	printf("%d\n", num);
	return 0;
}

//注册一个技术博客,可以是:CSDN,简书,51CTO等技术博客网站.
//写个人第一篇博客,访谈以下内容,
//1.写一个自我介绍
//2.列出你编程的目标
//3.你打算怎么学习编程,
//4.你打算在学习编程这件事上每周花费多长时间
//5.你最想进入的一家公司

int main()
{
	printf("        ⭐⭐\n");
	printf("        ⭐⭐\n");
	printf("⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐\n");
	printf("⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐\n");
	printf("      ⭐    ⭐\n");
	printf("      ⭐    ⭐\n");
	return 0;
}

//在下OJ online judge
//很多互联网公司在笔试环节都采用在线oj的形式
//
// 1. IO型 所有的代码都是自己来完成和实现 输入 计算 输出
//2. 接口型 只需要完成一个函数,假设其他需要的数据都是准备好的

int main()
{
	int a = 40;
	int c = 212;
	int r = (-8 + 22) * a - 10 + c / 2;
	printf("%d\n", r);
	return 0;
}

//0 - 数字0
//'0'- 字符0 -ascii码值是48
//'\0' - 字符 -ascii码值是0
//EOF -end of file 文件的结束标志 值是-1

int main()
{
	char arr[] = { 'b','i','t'};
 //如果 char arr[4] = {'b','i,'t'} 不完全初始化,剩余的部分默认值为0 strlen(arr) 为3 因为arr[4] 给了3个默认初始化值 第四个为0
	printf("%d\n", strlen(arr));
	return 0;
}

int main()
{
	//int arr[10]={1};
	int n = 10;
	//int arr[n] = { 0 };
	//c99标准之前,数组的大小都是用常量或者常量表达式来指定
	int arr2[10] = { 0 };
	int arr3[4 + 6] = { 1,2,3,4 };//常量表达式

	//c99之后,支持了变长数组,这个时候允许数组的大小是变量,但是这种指定方式的数组是不能初始化的
	int m = 100;
	int arr[m];

	return 0;
}
//vs对c99中的一些语法支持不是很好,不支持边长数组.

//windows操作系统
//Linux 开源操作系统 

int main() {

	char ch[10] = { "helloworld" };
	return 0;
}

int main()
{
	int a = 0;
	int b = 0;
	printf("请输入两个整数\n");
	scanf("%d %d", &a, &b);
	if (a > b) {
		printf("%d\n", a);
	}
	else if (a < b) {
		printf("%d\n", b);
	}
	else {
		printf("相等");
	}
	return 0;
}

Max(int x, int y)
{
	if (x > y)
		return x;
	else
		return y;
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	int r = Max(a, b);
	printf("%d\n", r);
	return 0;
}


int main()
{
	int x = 0;
	int y = 0;
	//printf("请输入一个整数\n");
	scanf("%d", &x);
	if (x > 0) {
		y = -1;
	}
	else if (x == 0) {

		y = 0;
	}
	else {
		y = 1;
	}
	printf("%d\n",y);
	return 0;
}



//操作符-- 灵活运用

int main()
{
	//int a = 7 / 2;
	//printf("%d\n", a);
	float a = 7 / 2.0;
	printf("%.1f\n", a);
	// 除号的两端都是整数的时候,执行的是整数除法,如果两端只要有一个浮点数,就执行浮点数的除法
	//int b = 7 % 2;
	//printf("%d\n", b);
	//取模操作符两端必须是整数
	return 0;
}

int main()
{
	//int flag = 2;
	//if (!flag) {
	//	printf("true");
	//}
	//int a = -10;
	//int b = +a;
	//printf("%d\n",b);

	//sizeof是单目操作符. 操作符!!
	//int a = 10;
	//printf("%d\n", sizeof(a));
	//printf("%d\n", sizeof(int));
	//printf("%d\n", sizeof a);
	////printf("%d\n", sizeof int);

	int arr[10] = { 0 };
	printf("%d\n", sizeof(arr));//40 计算的是数组的大小,单位是字节
	printf("%d\n", sizeof(arr[0]));
	printf("%d\n", sizeof(arr) / sizeof(arr[0]));
	return 0;
}


int main()
{
	//int a = 10;
	//int b = a++; //后置++ 先使用再++
	//int c = ++a;

	//printf("%d\n",a);
	//printf("%d\n",b);
	//printf("%d\n",c);

	int a = (int)3.14;
	printf("%d\n", a);

	return 0;
}

int main()
{
	int a = 10;
	int b = 20;
	int r = a > b ? a : b ;
	printf("%d\n", r);
	return 0;
}

int main()
{
	//逗号表达式 逗号隔开的一串表达式
	//特点:从左向右一次计算,整个表达式的结果是最后一个表达式的结果
	int a = 10;
	int b = 20;
	int c = 0;
	int d = (c = a - 2, a = b + c, c - 3);
	printf("%d\n", d);
	return 0;
}

//arr[3]  []下标引用操作符 arr和3就是[]的操作数
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int n = 3;
	arr[n]=20;
	for (int i = 0; i < 10; i++) {
		printf("%d ", arr[i]);
	}
	return 0;
}

//函数调用操作符
Add(int x, int y)
{
	return x + y;
}
int main()
{
	int sum = Add(2, 3);//()就是函数调用操作符,Add,2,3都是()的操作数

	return 0;
}

//常见关键字 -c语言本身内置的 ,不是能自己创造
//auto int short char long float double typedef-类型重命名 break continue signed
//while for case switch default if else goto const do enum extern
//  register 寄存器
// return sizeof -计算大小 static 静态的 struct 结构体
//  union 联合体共用体
//  unsigned void 无(函数的返回类型 ,函数参数) volatile - 类型修饰符
int main()
{
	auto int a = 0;//auto自动 被省略
	return 0;
}

//关键字typedef 类型定义 理解为 类型重命名

typedef unsigned int uint;

struct Node
{
	int data;
	struct Node* next;
}Node;
int main()
{
	unsigned int num = 0;
	uint num2 = 1;

	struct Node n;
	//Node n2;
	return 0;
}

 //栈区 堆区(动态内存管理 malloc/free/calloc/realloc) 静态区

//关键字 static
//1.修饰局部变量 局部变量除了作用域不销毁。
//  本质上static修饰局部变量的时候改变了变量的存储位置。
// 栈区 局部变量， static修饰后放入静态区。
// 影响了变量的生命周期，生命周期变长，和程序的生命周期一样。
//2.修饰全局变量
// 编译+链接 --> 可执行程序
// 全局变量是具有外部链接属性  
// static 修饰全局变量的时候 这个全局变量的外部连接属性就变成了内存连接属性.
// 其他源文件(.c)就不能再使用到这个全局变量了 
// 我们在使用的时候,就感觉作用域变小了 
//3  修饰函数
//  函数是具有外部链接属性的
//  一个函数本来是具有外部属性的,但是被static修饰的时候,外部连接属性就变成了内部链接属性,其他源文件(.c)就无法使用了 

void test()//test()执行任务，不许返回void
{
	static int a = 1;//没有对应汇编代码   这条代码不参与执行
	a++;//整个过程a的地址没有发生变化
	printf("%d ", a);
}
int main()
{
	int i = 0;
	while (i < 10)
	{
		test();
		i++;
	}
	return 0;
}
 
//修饰全局变量
extern int g_val;
//static int g_val=2024;
int main()
{
	printf("%d\n", g_val);
	return 0;
}

// static修饰函数
extern int Add(int x, int y);
int main()
{
	int a = 10;
	int b = 20;
	int z = Add(a, b);
	printf("%d\n", z);

	return 0;
}

//register 寄存器
// 电脑上的存储设备有哪些?
// 寄存器(集成到CPU上) 高速缓存(cache) 内存 硬盘
// 快(空间小,造价高) --------> 慢(空间大,造价低)
//CPU 中央处理器 

int main()
{
	//寄存器变量
	register int num = 3;//建议3存放在寄存中
	return 0;
}

//#define 定义常量和宏

//#define 定义标识符常量
#define NUM 100
int main()
{
	printf("%d\n", NUM);
	int n = NUM;
	printf("%d\n", n);
	int arr[NUM] = { 0 };
	return 0;
}

//#define 定义宏
// 宏是有参数的
#define ADD(x,y) ((x)+(y))//ADD宏名 xy宏的参数,参数是无类型 (()+())宏体
// 宏是完成替换的

//int ADD(int x, int y)
//{
//	return x + y;
//}

int main()
{
	int a = 10;
	int b = 20;
	int c=ADD(a, b);
	printf("%d\n", c); 

	return 0;
}

//.h 头文件 (函数的声明,类型的声明,头文件的包含)
//.c 源文件 (函数实现)
//
//浮点数的四舍五入,不能用你肉眼的数值来计算!!
//因为浮点数在内存中有可能不能精确保存;
//12.455 12.454988828282....接近没法进


//指针
// 内存会划分位一个个的内存单元(一个内存单元的大小:1byte)
//每个内存单元都有一个编号
//32位电脑 
//内存 
//32根地址线 2的32次方字节 = 4GB

int main()
{
	int a=10;//向内存申请4个字节,存储10
	//&a; //取地址符&
	printf("%p\n", &a);
	printf("%d\n", a);
	int* p = &a;//p就是指针变量 *说明p是指针变量 int说明p指向的对象int类型的  
	//地址也被称为指针
	//存放指针(地址) 的变量就是指针变量
	//p 指针变量 %p打印指针
	//*p 解引用操作符,意思是通过p中存放的地址,找到p所指的对象,*p就是p指向的对象
	*p = 20;
	printf("%d\n", a);

	char ch = 'w';
	char* pc = &ch;

	printf("%p", &ch);
	return 0;
}

int main()
{
	//不管是什么类型的指针,都是在创建指针变量
	//指针变量是用来存放地址的
	//指针变量的大小取决于一个地址存放的时候需要多大空间
	//32位机器上的地址:32bit位 - 4byte,所以指针变量的大小是4个字节
	//32位机器上的地址:64bit位 - 8byte,所以指针变量的大小是8个字节

	printf("%d\n", sizeof(char*));
	printf("%d\n", sizeof(int*));
	printf("%d\n", sizeof(float*));
	printf("%d\n", sizeof(short*));
	printf("%d\n", sizeof(double*));
	return 0;
}

//结构体
//结构体是把一些单一类型组合在一起的做法.

//学生
struct Stu 
{
	//成员
	char name[20];
	int age;
	char sex[10];
	char tele[12];
};
void print(struct Stu* ps)
{
	printf("%s %d %s %s\n", (*ps).name, (*ps).age, (*ps).sex, (*ps).tele);
	//->
	// 结构体指针变量->成员名
	printf("%s %d %s %s\n", ps->name, ps->age, ps->sex, ps->tele);
}
int main()
{
	struct Stu s = { "zhangsan ",11,"nan","123456789" };

	//结构体对象.成员名
	printf("%s %d %s %s\n", s.name, s.age, s.sex, s.tele);
	print(&s);
	return 0;
}

//define 不是关键字 是预处理指令

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("%d %d\n", a / b, a % b);
	return 0;
}





















//看看调试视频
//学C   多练 画图理解内存指针  学会调试 学习练习写博客
//考研 有没有能力  英语怎么样 数学怎么样  计算机基础怎么样 家里能不能支持
//csdn博客  github国外 gittee国内 慢慢扩展学习git不能只懂三板斧
//笔记软件 有道云笔记  xmind 思维导图  整理课程框架

// 如何学好c语言 
//C生万物 编程之本  长远IT职业发展的首选
//C语言是母体语言 是人机交互接近底层的桥梁
//学会C/C++ 相当于掌握技术核心
//知识点一竿子打通
//IT行业，一般每十年就有一次变革
//进五十年间，再TIOBE排行榜中，C/C++位置长期霸占前三名，没有丝毫撼动，可谓经典永不过时！！

//遇到问题 自己动手解决
//学好编程，不仅仅是学好C语言
//  必须要学好：计算机语言，数据结构，操作系统，计算机网络，项目实战，数据库
